import React, { Suspense } from 'react';
import Mysuspense from './Mysuspense';
export default function index() {
  var arr = ['old', 1, true, ['old1', 'old2'], { old: 1 }];
  // -------------------深拷贝----------------------
  var new_arr = JSON.parse(JSON.stringify(arr));
  arr[3][1] = 'off';
  //   console.log(new_arr);
  //   console.log(arr);

  // extend 实现多个对象合并到第一个对象
  //jQuery.extend( target [, object1 ] [, objectN ] )
  // 第一版
  function extend() {
    var name, options, src, copy;
    var length = arguments.length;
    var i = 1;
    var target = arguments[0];

    for (; i < length; i++) {
      options = arguments[i];
      if (options != null) {
        for (name in options) {
          //   src = target[name];
          copy = options[name];
          if (copy !== undefined) {
            target[name] = copy;
          }
        }
      }
    }

    return target;
  }
  var obj1 = {
    a: 1,
    b: { b1: 1, b2: 2 },
  };

  var obj2 = {
    b: { b1: 3, b3: 4 },
    c: 3,
  };

  var obj3 = {
    d: 4,
  };
  //   console.log(extend(obj1, obj2, obj3));

  // 第二版 实现深拷贝
  //jQuery.extend( [deep], target, object1 [, objectN ] )
  // 第一个参数deep表示是否深度遍历
  // 第二版
  function extend2() {
    // 默认不进行深拷贝
    var deep = false;
    var name, options, src, copy;
    var length = arguments.length;
    // 记录要复制的对象的下标
    var i = 1;
    // 第一个参数不传布尔值的情况下，target默认是第一个参数
    var target = arguments[0] || {};
    // 如果第一个参数是布尔值，第二个参数是才是target
    if (typeof target == 'boolean') {
      deep = target;
      target = arguments[i] || {};
      i++;
    }
    console.log(target);
    // 如果target不是对象，我们是无法进行复制的，所以设为{}
    if (typeof target !== 'object') {
      target = {};
    }

    // 循环遍历要复制的对象们
    for (; i < length; i++) {
      // 获取当前对象
      options = arguments[i];
      // 要求不能为空 避免extend(a,,b)这种情况
      if (options != null) {
        for (name in options) {
          // 目标属性值
          src = target[name];
          // 要复制的对象的属性值
          copy = options[name];

          if (deep && copy && typeof copy == 'object') {
            // 递归调用
            target[name] = extend2(deep, src, copy);
          } else if (copy !== undefined) {
            target[name] = copy;
          }
        }
      }
    }

    return target;
  }
  //   console.log(extend2(true, obj1, obj2, obj3));

  // 第三版 当目标对象和待拷贝对象类型不同时，即一个是对象一个是数组的情况
  //   function extend3() {
  //     // 默认不进行深拷贝
  //     var deep = false;
  //     var name, options, src, copy, clone, copyIsArray;
  //     var length = arguments.length;
  //     // 记录要复制的对象的下标
  //     var i = 1;
  //     // 第一个参数不传布尔值的情况下，target 默认是第一个参数
  //     var target = arguments[0] || {};
  //     // 如果第一个参数是布尔值，第二个参数是 target
  //     if (typeof target == 'boolean') {
  //       deep = target;
  //       target = arguments[i] || {};
  //       i++;
  //     }
  //     // 如果target不是对象，我们是无法进行复制的，所以设为 {}
  //     if (typeof target !== 'object' && !isFunction(target)) {
  //       target = {};
  //     }

  //     // 循环遍历要复制的对象们
  //     for (; i < length; i++) {
  //       // 获取当前对象
  //       options = arguments[i];
  //       // 要求不能为空 避免 extend(a,,b) 这种情况
  //       if (options != null) {
  //         for (name in options) {
  //           // 目标属性值
  //           src = target[name];
  //           // 要复制的对象的属性值
  //           copy = options[name];

  //           // 解决循环引用
  //           if (target === copy) {
  //             continue;
  //           }

  //           // 要递归的对象必须是 plainObject 或者数组
  //           if (
  //             deep &&
  //             copy &&
  //             (isPlainObject(copy) || (copyIsArray = Array.isArray(copy)))
  //           ) {
  //             // 要复制的对象属性值类型需要与目标属性值相同
  //             if (copyIsArray) {
  //               copyIsArray = false;
  //               clone = src && Array.isArray(src) ? src : [];
  //             } else {
  //               clone = src && isPlainObject(src) ? src : {};
  //             }

  //             target[name] = extend3(deep, clone, copy);
  //           } else if (copy !== undefined) {
  //             target[name] = copy;
  //           }
  //         }
  //       }
  //     }

  //     return target;
  //   }

  // -------------数组最大值-------------
  var arrs = [6, 4, 1, 8, 2, 11, 23];
  console.log(arrs);
  function max(prev, next) {
    return Math.max(prev, next);
  }
  console.log(arrs.reduce(max));

  var max2 = eval('Math.max(' + arrs + ')');
  console.log(max);

  // -----------------数组扁平化----------
  var arr12 = [1, [2, [3, 4]]];

  function flatten(arre) {
    while (arre.some((item) => Array.isArray(item))) {
      arre = [].concat(...arre);
      console.log(arre);
    }

    return arre;
  }

  console.log(flatten(arr12));
  return (
    <div>
      <Suspense fallback={<span>loading.....</span>}>
        <Mysuspense />
      </Suspense>
    </div>
  );
}
